Method and System for Retrieving Legal Data for User Interface Form Generation by Merging Syntactic and Semantic Contraints

ABSTRACT

An aspect of this invention is a method that includes receiving input data from an application. The input data includes information descriptive of at least one field. The method further includes processing the input data to form an array composed of legal data for the at least one field. The array is formed by merging a result of processing syntactic constraints and a result of processing semantic constraints. The method further includes outputting the array to the application. A system for performing the method is also described, as is a computer program product that can be used to execute the method.

TECHNICAL FIELD

The exemplary embodiments of this invention relate generally to methods,systems and computer program products configured for operating a systemto process extensible markup language (XML) documents derived from inputdata, such as a form having one or more fields.

BACKGROUND

The Schematron (Schematron.com) differs from other schema languages inthat it not based on grammars but instead on finding tree patterns in aparsed document. This approach is said to allow many kinds of structuresto be represented which are inconvenient and difficult in grammar-basedschema languages. The Schematron is said to allow the development andmixing two kinds of schemas: (a) report elements that allow diagnosingwhich variant of a language is being processed, and (b) assert elementsthat allow confirmation that a document conforms to a particular schema.

The Schematron is based on simple actions:

first, find context nodes in the document (typically an element) basedon XPath path criteria; and

then, check to determine if some other XPath expressions are true, foreach of the found context nodes.

An XML Path Language (XPath) expression uses a path notation, similar tothose used in URLs, for addressing parts of an XML document. Theexpression is evaluated to yield an object of the node-set, Boolean,number, or string type. For example, the expression X/Y will return anode-set of the <Y> elements contained in the <X> elements, if suchelements are declared in the source XML document.

Schematron is an example of a rule-based language that allows thespecification of semantic constraints. Schematron is based on the treepattern (XPath) and is capable of expressing constraints in ways thatother XML schema languages, such as XSD Schema and DTD cannot, e.g.,data values, (inter-)dependencies, co-constraints, data statetransitions, etc. and business rules.

Extensible markup language (XML) schemas express shared vocabularies andenable machines to carry out human-defined rules. XML schemas provide ameans for defining the structure, content and semantics of XMLdocuments.

In a general sense an XML schema is a description of a type of XMLdocument, typically expressed in terms of constraints on the structureand content of documents of that type, above and beyond the basicsyntactical constraints imposed by XML itself. These constraints aregenerally expressed using some combination of grammatical rulesgoverning the order of elements, Boolean predicates that the contentmust satisfy, data types governing the content of elements andattributes, and more specialized rules such as uniqueness andreferential integrity constraints.

Languages have been developed specifically to express XML schemas. TheDocument Type Definition (DTD) language, which is native to the XMLspecification, is one such type of language. Two more expressive XMLschema languages are XML Schema and RELAX.

The mechanism for associating an XML document with a schema variesaccording to the schema language. The association may be achieved viamarkup within the XML document itself, or via some external means.

Currently available languages for expressing XML schemas are deficientin certain respects, such as in providing an ability to employ acombination of syntactic and semantic constraints.

SUMMARY

In one aspect thereof the exemplary embodiments of this inventionprovide a method that includes receiving input data from an applicationcomprising information descriptive of at least one field; processing theinput data to form an array comprised of legal data for the at least onefield, the array being formed by merging a result of processingsyntactic constraints and a result of processing semantic constraints;and outputting the array to the application.

In another aspect thereof the exemplary embodiments of this inventionprovide a computer-readable medium that contains computer programinstructions, where execution of the computer program instructions by atleast one data processor results in performance of operations thatcomprise receiving input data from an application comprising informationdescriptive of at least one field; processing the input data to form anarray comprised of legal data for the at least one field, the arraybeing formed by merging a result of processing syntactic constraints anda result of processing semantic constraints; and outputting the array tothe application.

In yet another aspect thereof the exemplary embodiments of thisinvention provide a data processing system that comprises at least onedata processor connected with at least one memory that stores computerprogram instructions and at least one interface connected with the atleast one data processor and configured for conducting bidirectionalcommunications via at least one network. The at least one data processoroperates under control of the computer program instructions to receiveinput data from an application via the at least one interface, the inputdata comprising information descriptive of at least one field; toprocess the input data to form an array comprised of legal data for theat least one field, the array being formed by merging a result ofprocessing syntactic constraints and a result of processing semanticconstraints; and to output the array to the application via the at leastone interface.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

FIG. 1 illustrates an overall workflow in accordance with the exemplaryembodiments of this invention.

FIG. 2 shows in further detail how valid data is retrieved from semanticconstraints.

FIG. 3 illustrates Schematron rule examples.

FIG. 4 illustrates a more detailed example of an Array output showingthose elements derived from syntactic constraints and those elementsderived from semantic constraints.

FIG. 5 shows an example of a computer system that can be used toimplement the workflow of FIG. 1.

FIG. 6 is a logic flow diagram that is descriptive of a method of thisinvention, as well as the execution of computer program instructionsshown in FIG. 5.

DETAILED DESCRIPTION

The exemplary embodiments of this invention enable methods and apparatusto retrieve “legal” data for User Interface (UI) form generation bymerging syntactic and semantic constraints. Legal data, which can alsobe referred to as “valid” data, can be considered to include, asnon-limiting and non-exhaustive examples, data types and datastructures; data values, (inter-)dependencies and co-constraints; anddata state transitions. A desired output can include a list of legalvalues for each field of a form to be generated.

Note that the specifics of an input data assemblage that represents adocument, object, or array can depend on the specifics of a parserimplementation, as well on the programming language that is used. A dataassemblage can be viewed as encompassing any type of input data that canbe processed, such as an XML document, or an array structure having oneor more elements.

It is pointed out that while the embodiments of this invention will bedescribed in the context of XML documents, the embodiments of thisinvention are applicable to any tree-structure-based document such as,but not limited to, JSON, HTML and any SGML-based document.

FIG. 1 describes an overall workflow in accordance with the exemplaryembodiments of this invention. Major elements shown in FIG. 1 include aclient application 10 that can have an associated User Interface (UI)10A. The client application 10 generates input data 12 (a dataassemblage) that is comprised of desired fields 12A and partial data12B. A processor, referred to herein also as a service 14, accepts theinput data 12 and operates on the input data in conjunction with theoutput of a facts database (DB) 16 (providing a facts XML instance 16A),a data XML instance 15A provided from an input data XML parser function14A, semantic constraints of an XML document 17A and syntacticconstraints of an XML document 17B. In addition to the input data XMLparser function 14A the service 14 includes a function to performretrieval from semantic constraints 14B, a function to perform retrievalfrom syntactic constraints 14C and a legal data merge function 14D thatprovides as an output of the service 14 to the client application 10 anoutput array 18 with legal data for desired fields. In accordance withan aspect of this invention the output array 18 is formed by mergingoutputs of the retrieval from syntactic constraints 14B and syntacticconstraints 14C.

The workflow is initiated with the client application 10 requestingvalid data to display on the UI 10A or to forward to any otherapplication that requires the data. For example, assume that the clientapplication 10 requests a form in order to register in a particularwebsite. This form may contain text fields which are constrained by type(string) and length (e.g., 100 bytes). The form can also containcombination (combo) fields that list valid values for that particularfield. For example, one or more Date fields may be constrained to holdonly dates in the past or only dates in the future. Furthermore, combofields may be constrained by other fields. As one non-limiting example auser may need to select a city after selecting a state. The same canoccur in Date fields such as when a second Date field must be set tospecify a date that is further in the future than a date specified in afirst Date field. These types of constraints can be referred to asco-constraints and/or as inter-dependencies. For a co-constrained fieldthe user is required to specify the value of the field that thenconstrains the other field.

The input to the service 14 therefore contains: (i) the desired fields12A that the client application 10 needs to display in the form andwhich will also be used to validate the user's input, and (ii) anypartial data 12B regarding values that constrain one or more of thedesired fields.

The input data XML parser function 14A of the service 14 parses theinput data 12 into an XML document or documents (data XML instance 15A)in order to process the retrieval of the valid data from the specifiedsemantic constraints 17A and to subsequently merge the results with theretrieval from the syntactic constraints logic 17B. The operation of thelegal data merge function 14D involves adding to or combining with allof the legal values retrieved by the semantic constraints logic 14B andthe syntactic valid data output from the retrieval from syntacticconstraints function 14C. For example, the syntactic constraints definethe type of the desired field, while the semantic constraints define thelegal values for that field. These are merged into a field objectstructure (the output array 18) in such a manner that the clientapplication 10 can locate both the legal values and the field typeinformation in the same field object.

The retrieval from semantic constraints function 14B assumes that thereis at least one XML document (Facts XML instance document 16A) thatcontains facts of which a rule engine that forms a part of the retrievalfrom semantic constraints function 14B can use to infer if there areinter-dependencies. By taking the previous non-limiting example of thecity versus state dependencies, the Facts XML instance document 16Aretrieved from the Facts DB 16 could contain the following data:

<State value=”New York”>  <Cities>   <City>Albany</City>  <City>Binghamton</City>   <City>New York City</City>  </Cities></State>

FIG. 2 shows in further detail how the valid data is retrieved from thesemantic constraints. There is at least one document 17A that containsthe specification of the semantic constraints of a given XML document.This data is provided to a semantic constraints processor 20. Assume asa non-limiting example that the semantic constraints processor 20 isimplemented using Schematron. The document 17A is then the Schematronschema, and by adding semantics in the message retrieved from the Reportelement, one may specify XPath expressions that will be the output ofthe processor 20 and that will be used in a Result processor 22. TheResult processor 22 queries via facts query function 24 the Facts XMLinstance document 16A. After processing the results for all fields thatdepend on other fields and contain XPath expressions to be executed, theoutput of the Result processor 22 is an output array 26 with the legaldata for the desired fields specified in the Data XML instance 15A. Thearray 26 is input to the legal data merge function 14D shown in FIG. 1.

As an example of the implementation using Schematron, considering thefollowing table. Reference can also be made to FIG. 3 which illustratesSchematron rule examples. The output shown in FIG. 3 indicates that theCustomer field is required and depends on the pool field and the XPathexpression for returning legal values for the Customer field given thespecified pool.

Desired Field: subAccount for a Given Customer

<sch:rule context=“MenuForSubAccount”>   <sch:reporttest=“(/ValidationData/InputData/DesiredFields/  Workorder/subAccount=”)”> subAccount#not required#dependency:customer#//Facts/pool[@value=‘ <sch:value-of select  = “/ValidationData/InputData/Workorder/pool”/>’]/customer[@value=‘<sch:value-of  select=“/ValidationData/InputData/Workorder/customer” />’]/subAccount#   </sch:report></sch:rule>

In this example the client application 10 has requested valid data todisplay in the combination of the subAccount field. Because this list ofvalues depends on other fields (in the example, pool and customer),values for these fields are needed as input.

However, Schematron cannot process XPath expressions in the Reportmessages, only during the test, in this case:

<sch:reporttest=“(/ValidationData/InputData/DesiredFields/Workorder/subAccount=”)”>,

where a check is made to determine if the subAccount field was specifiedas being required.

Schematron will output the following message:

subAccount#not required#dependency:customer#//Facts/pool[@value=‘<sch:value-of  select  = “/ValidationData/InputData/Workorder/pool”/>’]/customer[@value=‘<sch:value-of select=“/ValidationData/InputData/Workorder/customer” />’]/subAccount#

This must conform to the following:

<fieldName>*#<‘required’ or ‘notrequired’>*#dependency:<field>#<XPath_expression>#<message>

What is meant in the foregoing non-limiting example is that thesubAccount field is not required, and depends on the customer field(which depends on the pool field), and the XPath expression forobtaining the valid data for the subAccount field given the specifiedcustomer and pool.

The fields with * mean that they are always required to be specified,while the other fields (dependency, XPath expression and message) dependon the type of constraint.

For example, the Facts XML instance document 16A contains values in thefollowing tree-structure:

<Pool/>       <Customer/>   <SubAccount/>

Referring also to FIG. 1, the output array 24 with the valid dataretrieved from the semantic constraints processor 20 and resultprocessor 22 logic will be merged with the output of the syntacticconstraints logic 14C in the legal data merge function 14 to provide theoutput array 18 with the legal data for the desired fields.

Assume that the syntactic constraints logic was specified with XMLSchema, referred to as XSD. As but one example, US Patent Publication2006/0288270 A1, “Automated Presentation Layer Generation”, describes amethod for performing parsing, loading and using valid data retrievedfrom an XSD schema. The parser of the XSD schema extracts the valid datafor the desired fields into an Array 26 to be merged by Legal Data Mergefunction 14D (FIG. 1) with the semantic constraints logic 14B output.The merged output array 18 is then returned to the client application20. The merged output array 18 may be acceptable as is, otherwise theclient application 10 can iterate over the workflow in order to requestmore valid data for co-constrained fields not previously specified(e.g., because the values were not available).

FIG. 4 illustrates an example of the output (merged) array 18 showingthose elements derived from syntactic constraints and those elementsderived from semantic constraints.

In accordance with the exemplary embodiments of this invention, bymerging the results of syntactic constraints with semantic constraintsthe UI form generation becomes more powerful. This is true at least forthe reason that the operation of the service 14 of FIG. 1 complementsthe valid (legal) values for each field with the results of constraintson data values, (inter-)dependencies, co-constraints and data statetransitions, among others, which are typically needed to expressbusiness rules.

FIG. 5 shows an example of a computer system or data processing system100 that can be used to implement the service 14 of FIG. 1. As will bediscussed in even further detail below, at least one computer or dataprocessor 102 is connected with at least one computer readable mediumsuch as a memory device or a memory system 104 that stores computerprogram instructions 106. Execution of the computer program instructions106 results in the performance of methods in accordance with thisinvention. The system 100 can be implemented as, for example, a personalcomputer-type device, as a workstation-type device or as a main frametype device. The at least one data processor 102 can be implemented inany suitable form including as one or microprocessors ormicrocontrollers. The memory device or system 104 can be implemented asone or more of, for example, solid state memory including dynamic RAMand/or static RAM, Flash memory, magnetic memory including disk and/ortape, or as optical memory. The computer program instructions 106 can bewritten in any suitable programming language and can be compiled priorto execution or executed by an interpreter. The system 100 includes atleast one interface 108 that enables bidirectional communication withone or more external systems, memories and/or user terminals, such asthe client application 10 shown in FIG. 1. The at least one interface108 can be configured to interface to a network 110, such as one or bothof a local area network (LAN) and a wide area network (WAN) such as theInternet, via wired or wireless communication paths.

Note that in some embodiments the workflow depicted in FIG. 1 may becontained in whole or in part in the system that hosts the clientapplication 10 and, as such, the interface 108 may be an internalinterface such as a local data bus for example.

FIG. 6 is a logic flow diagram that is descriptive of a method of thisinvention, as well as the execution of the computer program instructions106 shown in FIG. 5. At Block 60 there is a step of receiving input datafrom an application comprising information descriptive of at least onefield. At Block 62 there is a step of processing the input data to forman array comprised of legal data for the at least one field, the arraybeing formed by merging a result of processing syntactic constraints anda result of processing semantic constraints. At Block 64 there is a stepof outputting the array to the application.

As should be appreciated by one skilled in the art, aspects of thepresent invention may be embodied as a system, method, computer programproduct or as a combination of these. Accordingly, aspects of thepresent invention may take the form of an entirely hardware embodiment,an entirely software embodiment (including firmware, resident software,micro-code, etc.) or an embodiment combining software and hardwareaspects that may all generally be referred to herein as a “circuit”,“module” or “system”. Furthermore, aspects of the present invention maytake the form of a computer program product embodied in one or morecomputer readable medium(s) having computer readable program codeembodied thereon.

Any combination of one or more computer readable medium(s) may beutilized. The computer readable medium may be a computer readable signalmedium or a computer readable storage medium. A computer readablestorage medium maybe, for example, but not limited to, an electronic,magnetic, optical, electromagnetic, infrared, or semiconductor system,apparatus, or device, or any suitable combination of the foregoing. Morespecific examples (a non-exhaustive list) of the computer readablestorage medium would include the following: an electrical connectionhaving one or more wires, a portable computer diskette, a hard disk, arandom access memory (RAM), a read-only memory (ROM), an erasableprogrammable read-only memory (EPROM or Flash memory), an optical fiber,a portable compact disc read-only memory (CD-ROM), an optical storagedevice, a magnetic storage device, or any suitable combination of theforegoing. In the context of this document a computer readable storagemedium may be any tangible, non-transitory medium that can contain, orstore a program for use by or in connection with an instructionexecution system, apparatus, or device.

A computer readable signal medium may include a propagated data signalwith computer readable program code embodied therein, for example, inbaseband or as part of a carrier wave. Such a propagated signal may takeany of a variety of forms, including, but not limited to,electro-magnetic, optical, or any suitable combination thereof. Acomputer readable signal medium may be any computer readable medium thatis not a computer readable storage medium and that can communicate,propagate, or transport a program for use by or in connection with aninstruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmittedusing any appropriate medium, including but not limited to wireless,wireline, optical fiber cable, RF, etc., or any suitable combination ofthe foregoing.

Computer program code for carrying out operations for aspects of thepresent invention may be written in any combination of one or moreprogramming languages, including an object oriented programming languagesuch as Java, Smalltalk, C++ or the like and conventional proceduralprogramming languages, such as the “C” programming language or similarprogramming languages. The program code may execute entirely on thecomputer, partly on the computer, as a stand-alone software package,partly on the computer and partly on a remote computer or entirely onthe remote computer or server. In the latter scenario, the remotecomputer may be connected to the computer through any type of network,including a local area network (LAN) or a wide area network (WAN), orthe connection may be made to an external computer (for example, throughthe Internet using an Internet Service Provider).

Aspects of the present invention are described with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems) and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer program instructions. These computer program instructions maybe provided to a processor of a general purpose computer, specialpurpose computer, or other programmable data processing apparatus toproduce a machine, such that the instructions, which execute via theprocessor of the computer or other programmable data processingapparatus, create means for implementing the functions/acts specified inthe flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in a computerreadable medium that can direct a computer, other programmable dataprocessing apparatus, or other devices to function in a particularmanner, such that the instructions stored in the computer readablemedium produce an article of manufacture including instructions whichimplement the function/act specified in the flowchart and/or blockdiagram block or blocks.

The computer program instructions may also be loaded onto a computer,other programmable data processing apparatus, or other devices to causea series of operational steps to be performed on the computer, otherprogrammable apparatus or other devices to produce a computerimplemented process such that the instructions which execute on thecomputer or other programmable apparatus provide processes forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof code, which comprises one or more executable instructions forimplementing the specified logical function(s). It should also be notedthat, in some alternative implementations, the functions noted in theblock may occur out of the order noted in the figures. For example, twoblocks shown in succession may, in fact, be executed substantiallyconcurrently, or the blocks may sometimes be executed in the reverseorder, depending upon the functionality involved. It will also be notedthat each block of the block diagrams and/or flowchart illustration, andcombinations of blocks in the block diagrams and/or flowchartillustration, can be implemented by special purpose hardware-basedsystems that perform the specified functions or acts, or combinations ofspecial purpose hardware and computer instructions.

The terminology used herein is for the purpose of describing particularembodiments only and is not intended to be limiting of the invention. Asused herein, the singular forms “a”, “an” and “the” are intended toinclude the plural forms as well, unless the context clearly indicatesotherwise. It will be further understood that the terms “comprises”and/or “comprising,” when used in this specification, specify thepresence of stated features, integers, steps, operations, elements,and/or components, but do not preclude the presence or addition of oneor more other features, integers, steps, operations, elements,components, and/or groups thereof.

The corresponding structures, materials, acts, and equivalents of allmeans or step plus function elements in the claims below are intended toinclude any structure, material, or act for performing the function incombination with other claimed elements as specifically claimed. Thedescription of the present invention has been presented for purposes ofillustration and description, but is not intended to be exhaustive orlimited to the invention in the form disclosed. Many modifications andvariations will be apparent to those of ordinary skill in the artwithout departing from the scope and spirit of the invention. Theembodiment was chosen and described in order to best explain theprinciples of the invention and the practical application, and to enableothers of ordinary skill in the art to understand the invention forvarious embodiments with various modifications as are suited to theparticular use contemplated.

As such, various modifications and adaptations may become apparent tothose skilled in the relevant arts in view of the foregoing description,when read in conjunction with the accompanying drawings and the appendedclaims. As but some examples, the use of other similar or equivalentmathematical expressions may be used by those skilled in the art.However, all such and similar modifications of the teachings of thisinvention will still fall within the scope of this invention.

What is claimed is:
 1. A method comprising: receiving input data from anapplication comprising information descriptive of at least one field;processing the input data to form an array comprised of legal data forthe at least one field, the array being formed by merging a result ofprocessing syntactic constraints and a result of processing semanticconstraints; and outputting the array to the application.
 2. The methodof claim 1, further comprising parsing the input data using an XMLparser to derive a data XML instance.
 3. The method of claim 2, wherethe input data that is parsed is comprised of desired fields and partialdata related to the desired fields.
 4. The method of claim 3, where thepartial data is comprised of one or more values that constrain one ormore of the desired fields.
 5. The method of claim 2, where the data XMLinstance is used, when processing semantic constraints, in conjunctionwith a facts XML instance obtained from a facts database.
 6. The methodof claim 1, where the array is formed so that the application can locateboth the legal values and field type information in a same field object.7. The method of claim 1, where the array is formed so as to complementthe legal values for the at least one field with results of constraintson at least one of data values, (inter-)dependencies, co-constraints anddata state transitions.
 8. The method of claim 1, where the input datais descriptive of a data assemblage representing a form containing theat least field.
 9. A computer program product embodied on anon-transitory computer-readable medium, where execution of the computerprogram product results in performance of the method as claimed inclaim
 1. 10. A computer-readable medium that contains computer programinstructions, the execution of the computer program instructions by atleast one data processor results in performance of operations thatcomprise: receiving input data from an application comprisinginformation descriptive of at least one field; processing the input datato form an array comprised of legal data for the at least one field, thearray being formed by merging a result of processing syntacticconstraints and a result of processing semantic constraints; andoutputting the array to the application.
 11. The computer-readablemedium of claim 10, further comprising an operation of parsing the inputdata using an XML parser to derive a data XML instance.
 12. Thecomputer-readable medium of claim 11, where the input data that isparsed is comprised of desired fields and partial data related to thedesired fields.
 13. The computer-readable medium of claim 12, where thepartial data is comprised of one or more values that constrain one ormore of the desired fields.
 14. The computer-readable medium of claim11, where the data XML instance is used, when processing semanticconstraints, in conjunction with a facts XML instance obtained from afacts database.
 15. The computer-readable medium of claim 10, where thearray is formed so that the application can locate both the legal valuesand field type information in a same field object.
 16. Thecomputer-readable medium of claim 10, where the array is formed so as tocomplement the legal values for the at least one field with results ofconstraints on at least one of data values, (inter-)dependencies,co-constraints and data state transitions.
 17. The computer-readablemedium of claim 10, where the input data is descriptive of a dataassemblage representing a form containing the at least field.
 18. A dataprocessing system, comprising: at least one data processor connectedwith at least one memory that stores computer program instructions; atleast one interface connected with the at least one data processor andconfigured for conducting bidirectional communications via at least onenetwork; said at least one data processor operating under control of thecomputer program instructions to receive input data from an applicationvia the at least one interface, the input data comprising informationdescriptive of at least one field; said at least one data processoroperating under control of the computer program instructions to processthe input data to form an array comprised of legal data for the at leastone field, the array being formed by merging a result of processingsyntactic constraints and a result of processing semantic constraints;and said at least one data processor further operating under control ofthe computer program instructions to output the array to the applicationvia the at least one interface.
 19. The data processing system of claim18, said at least one data processor further operating under control ofthe computer program instructions to parse the input data using an XMLparser to derive a data XML instance.
 20. The data processing system ofclaim 19, where the input data that is parsed is comprised of desiredfields and partial data related to the desired fields.
 21. The dataprocessing system of claim 20, where the partial data is comprised ofone or more values that constrain one or more of the desired fields. 22.The data processing system of claim 19, where the data XML instance isused, when processing semantic constraints, in conjunction with a factsXML instance obtained from a facts database.
 23. The data processingsystem of claim 18, where the array is formed so that the applicationcan locate both the legal values and field type information in a samefield object.
 24. The data processing system of claim 18, where thearray is formed so as to complement the legal values for the at leastone field with results of constraints on at least one of data values,(inter-)dependencies, co-constraints and data state transitions.
 25. Thedata processing system of claim 18, where the input data is descriptiveof a data assemblage representing a form containing the at least field.